#include <stdio.h>
#include <string.h>
#include "Window.h"
#include "All_struct.h"

// 工具函数：清除输入缓冲区换行符
static void clear_n(void) {
    int ch;
    while ((ch = getchar()) != '\n' && ch != EOF);
}

// 工具函数：检查窗口编号是否已存在（内部使用）
static int is_window_id_exist(Restaurant *pR, int target_id) {
    for (int i = 0; i < pR->window_count; i++) {
        if (pR->windows[i].window_id == target_id) {
            return 1; // 已存在
        }
    }
    return 0; // 不存在
}

// 3. 新增窗口（1=成功，0=失败）
int Window_add(Restaurant *pR) {
    // 空指针检查
    if (pR == NULL) {
        printf("错误：餐馆不存在！\n");
        return 0;
    }
    // 窗口数达上限
    if (pR->window_count >= MAX_WINDOW_PER_RESTAURANT) {
        printf("错误：窗口数已达上限（%d个），无法新增！\n", MAX_WINDOW_PER_RESTAURANT);
        return 0;
    }

    int new_idx = pR->window_count; // 新窗口的索引
    int new_id;
    // 读取窗口编号（确保唯一）
    printf("请输入新窗口编号：");
    while (1) {
        if (scanf("%d", &new_id) != 1 || new_id < 1) {
            clear_n();
            printf("输入错误！请输入正整数编号：");
        } else if (is_window_id_exist(pR, new_id)) {
            clear_n();
            printf("编号%d已存在！请输入新编号：", new_id);
        } else {
            clear_n();
            break;
        }
    }

    // 读取窗口名称
    printf("请输入新窗口名称（无空格）：");
    scanf("%s", pR->windows[new_idx].window_name);
    clear_n();

    // 初始化窗口默认状态
    pR->windows[new_idx].window_id = new_id;
    pR->windows[new_idx].dish_count = 0;   // 初始无菜品
    pR->windows[new_idx].order_count = 0;  // 初始无订单
    pR->windows[new_idx].window_state = 0; // 初始打烊

    // 新增成功：有效窗口数+1
    pR->window_count++;
    printf("新增窗口成功！编号：%d，名称：%s，当前共%d个窗口\n", 
           new_id, pR->windows[new_idx].window_name, pR->window_count);
    return 1;
}

// 4. 删除窗口（1=成功，0=失败）
int Window_delete(Restaurant *pR) {
    if (pR == NULL) {
        printf("错误：餐馆不存在！\n");
        return 0;
    }
    if (pR->window_count == 0) {
        printf("错误：当前无窗口，无法删除！\n");
        return 0;
    }

    // 查找要删除的窗口
    int del_id;
    printf("请输入要删除的窗口编号：");
    scanf("%d", &del_id);
    clear_n();

    int del_idx = -1;
    for (int i = 0; i < pR->window_count; i++) {
        if (pR->windows[i].window_id == del_id) {
            del_idx = i;
            break;
        }
    }
    if (del_idx == -1) {
        printf("未找到编号为%d的窗口！\n", del_id);
        return 0;
    }

    // 执行删除：后面的窗口往前移（覆盖删除）
    for (int j = del_idx; j < pR->window_count - 1; j++) {
        pR->windows[j] = pR->windows[j + 1];
    }
    // 有效窗口数-1
    pR->window_count--;
    printf("删除窗口（编号：%d）成功！当前共%d个窗口\n", del_id, pR->window_count);
    return 1;
}

// 5. 更新窗口信息（1=成功，0=失败）
int Window_update(Restaurant *pR) {
    if (pR == NULL) {
        printf("错误：餐馆不存在！\n");
        return 0;
    }
    if (pR->window_count == 0) {
        printf("错误：当前无窗口，无法更新！\n");
        return 0;
    }

    // 查找目标窗口
    int update_id;
    printf("请输入要更新的窗口编号：");
    scanf("%d", &update_id);
    clear_n();

    int update_idx = -1;
    for (int i = 0; i < pR->window_count; i++) {
        if (pR->windows[i].window_id == update_id) {
            update_idx = i;
            break;
        }
    }
    if (update_idx == -1) {
        printf("未找到编号为%d的窗口！\n", update_id);
        return 0;
    }

    // 显示原信息
    Window *win = &pR->windows[update_idx];
    printf("当前窗口信息：编号=%d，名称=%s，状态=%s\n",
           win->window_id, win->window_name,
           win->window_state ? "营业" : "打烊");

    // 更新编号（可选，确保唯一）
    int new_id;
    printf("是否更新窗口编号？（1=是，0=否）：");
    scanf("%d", &new_id);
    clear_n();
    if (new_id == 1) {
        printf("请输入新编号：");
        while (1) {
            if (scanf("%d", &new_id) != 1 || new_id < 1) {
                clear_n();
                printf("输入错误！请输入正整数：");
            } else if (is_window_id_exist(pR, new_id) && new_id != win->window_id) {
                clear_n();
                printf("编号%d已存在！请重新输入：", new_id);
            } else {
                clear_n();
                win->window_id = new_id;
                break;
            }
        }
    }

    // 更新名称
    char new_name[30];
    printf("是否更新窗口名称？（1=是，0=否）：");
    scanf("%d", &new_id); // 复用new_id变量
    clear_n();
    if (new_id == 1) {
        printf("请输入新名称：");
        scanf("%s", new_name);
        clear_n();
        strncpy(win->window_name, new_name, sizeof(win->window_name) - 1);
        win->window_name[sizeof(win->window_name) - 1] = '\0';
    }

    // 更新营业状态
    int new_state;
    printf("是否更新营业状态？（1=是，0=否）：");
    scanf("%d", &new_id);
    clear_n();
    if (new_id == 1) {
        printf("请输入新状态（1=营业，0=打烊）：");
        while (scanf("%d", &new_state) != 1 || (new_state != 0 && new_state != 1)) {
            clear_n();
            printf("输入错误！仅支持1（营业）或0（打烊）：");
        }
        clear_n();
        win->window_state = new_state;
    }

    printf("更新窗口成功！新信息：编号=%d，名称=%s，状态=%s\n",
           win->window_id, win->window_name, win->window_state ? "营业" : "打烊");
    return 1;
}

// 6. 查找窗口（1=成功，0=失败）
int Window_find(Restaurant *pR) {
    if (pR == NULL) {
        printf("错误：餐馆不存在！\n");
        return 0;
    }
    if (pR->window_count == 0) {
        printf("错误：当前无窗口，无法查找！\n");
        return 0;
    }

    int find_id;
    printf("请输入要查找的窗口编号：");
    scanf("%d", &find_id);
    clear_n();

    for (int i = 0; i < pR->window_count; i++) {
        Window *win = &pR->windows[i];
        if (win->window_id == find_id) {
            printf("================ 窗口信息 ================\n");
            printf("窗口编号：%d\n", win->window_id);
            printf("窗口名称：%s\n", win->window_name);
            printf("营业状态：%s\n", win->window_state ? "营业" : "打烊");
            printf("当前菜品数：%d道\n", win->dish_count);
            printf("当前订单数：%d个\n", win->order_count);
            printf("==========================================\n");
            return 1;
        }
    }

    printf("未找到编号为%d的窗口！\n", find_id);
    return 0;
}

// 7. 新增窗口订单（1=成功，0=失败）
int Window_Order_add(Window *pWin) {
    if (pWin == NULL) {
        printf("错误：窗口不存在！\n");
        return 0;
    }
    if (pWin->window_state == 0) {
        printf("错误：窗口已打烊，无法新增订单！\n");
        return 0;
    }
    if (pWin->dish_count == 0) {
        printf("错误：窗口无菜品，无法下单！\n");
        return 0;
    }
    if (pWin->order_count >= MAX_DISH_PER_WINDOW) {
        printf("错误：订单数已达上限（%d个），无法新增！\n", MAX_DISH_PER_WINDOW);
        return 0;
    }

    // 显示菜品列表
    printf("当前窗口菜品列表：\n");
    for (int i = 0; i < pWin->dish_count; i++) {
        Dish *d = &pWin->dishes[i];
        printf("序号：%d | 编号：%d | 名称：%s | 单价：%.2f元 | 库存：%d道\n",
               i + 1, d->id, d->name, d->price, d->stock);
    }

    // 选择菜品（按序号）
    int dish_idx;
    printf("请选择要下单的菜品序号（1-%d）：", pWin->dish_count);
    while (scanf("%d", &dish_idx) != 1 || dish_idx < 1 || dish_idx > pWin->dish_count) {
        clear_n();
        printf("输入错误！请输入1-%d之间的序号：", pWin->dish_count);
    }
    clear_n();
    dish_idx--; // 转为数组索引

    // 输入购买数量
    int buy_num;
    Dish *target_dish = &pWin->dishes[dish_idx];
    printf("请输入购买数量（当前库存：%d道）：", target_dish->stock);
    while (scanf("%d", &buy_num) != 1 || buy_num < 1 || buy_num > target_dish->stock) {
        clear_n();
        if (buy_num < 1) {
            printf("输入错误！请输入正整数：");
        } else {
            printf("库存不足！最大可买%d道：", target_dish->stock);
        }
    }
    clear_n();

    // 新增订单（扣减库存）
    int order_idx = pWin->order_count;
    pWin->Orders[order_idx] = *target_dish;
    pWin->Orders[order_idx].stock = buy_num; // 订单中stock表示购买数量
    target_dish->stock -= buy_num;           // 扣减菜品库存

    pWin->order_count++;
    printf("下单成功！订单信息：%s（%d份），单价%.2f元\n",
           target_dish->name, buy_num, target_dish->price);
    return 1;
}

// 8. 删除窗口订单（1=成功，0=失败）
int Window_Order_delete(Window *pWin) {
    if (pWin == NULL) {
        printf("错误：窗口不存在！\n");
        return 0;
    }
    if (pWin->order_count == 0) {
        printf("错误：当前无订单，无法删除！\n");
        return 0;
    }

    // 显示订单列表
    printf("当前窗口订单列表：\n");
    for (int i = 0; i < pWin->order_count; i++) {
        Dish *order = &pWin->Orders[i];
        printf("订单序号：%d | 菜品：%s | 数量：%d份 | 单价：%.2f元\n",
               i + 1, order->name, order->stock, order->price);
    }

    // 选择要删除的订单
    int order_idx;
    printf("请输入要删除的订单序号（1-%d）：", pWin->order_count);
    while (scanf("%d", &order_idx) != 1 || order_idx < 1 || order_idx > pWin->order_count) {
        clear_n();
        printf("输入错误！请输入1-%d之间的序号：", pWin->order_count);
    }
    clear_n();
    order_idx--; // 转为数组索引

    // 恢复库存（删除订单=取消购买）
    Dish *del_order = &pWin->Orders[order_idx];
    // 找到对应菜品并恢复库存
    for (int i = 0; i < pWin->dish_count; i++) {
        if (pWin->dishes[i].id == del_order->id) {
            pWin->dishes[i].stock += del_order->stock;
            break;
        }
    }

    // 订单数组前移（覆盖删除）
    for (int j = order_idx; j < pWin->order_count - 1; j++) {
        pWin->Orders[j] = pWin->Orders[j + 1];
    }
    pWin->order_count--;

    printf("删除订单成功！已恢复%s库存（+%d道）\n", del_order->name, del_order->stock);
    return 1;
}

// 9. 修改窗口订单（1=成功，0=失败）
int Window_Order_update(Window *pWin) {
    if (pWin == NULL) {
        printf("错误：窗口不存在！\n");
        return 0;
    }
    if (pWin->order_count == 0) {
        printf("错误：当前无订单，无法修改！\n");
        return 0;
    }

    // 显示订单列表
    printf("当前窗口订单列表：\n");
    for (int i = 0; i < pWin->order_count; i++) {
        Dish *order = &pWin->Orders[i];
        printf("订单序号：%d | 菜品：%s | 数量：%d份 | 单价：%.2f元\n",
               i + 1, order->name, order->stock, order->price);
    }

    // 选择要修改的订单
    int order_idx;
    printf("请输入要修改的订单序号（1-%d）：", pWin->order_count);
    while (scanf("%d", &order_idx) != 1 || order_idx < 1 || order_idx > pWin->order_count) {
        clear_n();
        printf("输入错误！请输入1-%d之间的序号：", pWin->order_count);
    }
    clear_n();
    order_idx--;
    Dish *target_order = &pWin->Orders[order_idx];

    // 找到对应菜品（用于检查库存）
    Dish *target_dish = NULL;
    for (int i = 0; i < pWin->dish_count; i++) {
        if (pWin->dishes[i].id == target_order->id) {
            target_dish = &pWin->dishes[i];
            break;
        }
    }
    if (target_dish == NULL) {
        printf("错误：订单对应菜品已下架，无法修改！\n");
        return 0;
    }

    // 输入新数量
    int old_num = target_order->stock;
    int new_num;
    printf("当前购买数量：%d份，当前库存：%d道（含已下单数量）\n",
           old_num, target_dish->stock + old_num); // 库存+已下单=总可售
    printf("请输入新的购买数量：");
    while (scanf("%d", &new_num) != 1 || new_num < 1 || new_num > (target_dish->stock + old_num)) {
        clear_n();
        if (new_num < 1) {
            printf("输入错误！请输入正整数：");
        } else {
            printf("库存不足！最大可买%d份：", target_dish->stock + old_num);
        }
    }
    clear_n();

    // 调整库存（新数量-旧数量=库存变化）
    target_dish->stock += (old_num - new_num);
    // 更新订单数量
    target_order->stock = new_num;

    printf("修改订单成功！%s数量从%d份改为%d份，库存已同步调整\n",
           target_order->name, old_num, new_num);
    return 1;
}

// 10. 设置窗口营业状态
void Window_set_open(Window *pWin, int is_open) {
    if (pWin == NULL) {
        printf("错误：窗口不存在！\n");
        return;
    }
    // 校验状态合法性
    if (is_open != 0 && is_open != 1) {
        printf("错误：状态无效！仅支持1（营业）或0（打烊）\n");
        return;
    }
    pWin->window_state = is_open;
    printf("窗口%s状态已设置为：%s\n",
           pWin->window_name, is_open ? "营业" : "打烊");
}

// 11. 批量设置所有窗口状态
void Restaurant_batch_set_window_status(Restaurant *pR, int is_open) {
    if (pR == NULL) {
        printf("错误：餐馆不存在！\n");
        return;
    }
    if (is_open != 0 && is_open != 1) {
        printf("错误：状态无效！仅支持1（营业）或0（打烊）\n");
        return;
    }
    if (pR->window_count == 0) {
        printf("当前无窗口，无需设置状态！\n");
        return;
    }

    // 遍历所有有效窗口
    for (int i = 0; i < pR->window_count; i++) {
        pR->windows[i].window_state = is_open;
    }
    printf("批量设置完成！所有%d个窗口已切换为%s状态\n",
           pR->window_count, is_open ? "营业" : "打烊");
}